#ifndef ENHANCED_CHAT_SYSTEM_H
#define ENHANCED_CHAT_SYSTEM_H

#include "common.h"
#include <unordered_map>
#include <unordered_set>

// 聊天类型
enum ChatType {
    CHAT_PRIVATE = 1,    // 单聊
    CHAT_GROUP = 2       // 群聊
};

// 增强的消息类型
enum EnhancedMessageType {
    ENHANCED_MSG_LOGIN = 1,
    ENHANCED_MSG_LOGOUT = 2,
    ENHANCED_MSG_PRIVATE_CHAT = 3,        // 私聊消息
    ENHANCED_MSG_GROUP_CHAT = 4,          // 群聊消息
    ENHANCED_MSG_CREATE_GROUP = 5,        // 创建群组
    ENHANCED_MSG_JOIN_GROUP = 6,          // 加入群组
    ENHANCED_MSG_LEAVE_GROUP = 7,         // 离开群组
    ENHANCED_MSG_INVITE_TO_GROUP = 8,     // 邀请入群
    ENHANCED_MSG_USER_LIST = 9,           // 用户列表
    ENHANCED_MSG_GROUP_LIST = 10,         // 群组列表
    ENHANCED_MSG_CHAT_HISTORY = 11,       // 聊天记录
    ENHANCED_MSG_USER_STATUS = 12,        // 用户状态
    ENHANCED_MSG_ERROR = 13
};

// 用户状态
enum UserStatus {
    STATUS_OFFLINE = 0,
    STATUS_ONLINE = 1,
    STATUS_BUSY = 2,
    STATUS_AWAY = 3
};

// 群组角色
enum GroupRole {
    ROLE_MEMBER = 1,
    ROLE_ADMIN = 2,
    ROLE_OWNER = 3
};

// 增强消息结构
struct EnhancedMessage {
    EnhancedMessageType type;
    std::string messageId;       // 消息唯一ID
    std::string fromUser;        // 发送者
    std::string toUser;          // 接收者(私聊)
    std::string groupId;         // 群组ID(群聊)
    std::string content;         // 消息内容
    time_t timestamp;            // 时间戳
    ChatType chatType;           // 聊天类型
    
    EnhancedMessage() : type(MSG_PRIVATE_CHAT), timestamp(time(nullptr)), chatType(CHAT_PRIVATE) {}
    
    EnhancedMessage(EnhancedMessageType t, const std::string& from, const std::string& cnt)
        : type(t), fromUser(from), content(cnt), timestamp(time(nullptr)), chatType(CHAT_PRIVATE) {}
    
    // 序列化消息
    std::string serialize() const {
        return std::to_string(static_cast<int>(type)) + "|" + 
               messageId + "|" + fromUser + "|" + toUser + "|" + 
               groupId + "|" + content + "|" + std::to_string(timestamp) + "|" +
               std::to_string(static_cast<int>(chatType));
    }
    
    // 反序列化消息
    static EnhancedMessage deserialize(const std::string& data) {
        EnhancedMessage msg;
        std::vector<std::string> parts;
        std::stringstream ss(data);
        std::string item;
        
        while (std::getline(ss, item, '|')) {
            parts.push_back(item);
        }
        
        if (parts.size() >= 8) {
            msg.type = static_cast<EnhancedMessageType>(std::stoi(parts[0]));
            msg.messageId = parts[1];
            msg.fromUser = parts[2];
            msg.toUser = parts[3];
            msg.groupId = parts[4];
            msg.content = parts[5];
            msg.timestamp = std::stoll(parts[6]);
            msg.chatType = static_cast<ChatType>(std::stoi(parts[7]));
        }
        return msg;
    }
};

// 增强私聊会话
struct EnhancedPrivateChat {
    std::string chatId;          // 聊天ID
    std::string user1;           // 参与者1
    std::string user2;           // 参与者2
    time_t createTime;           // 创建时间
    time_t lastActiveTime;       // 最后活跃时间
    std::vector<EnhancedMessage> messages;  // 消息历史
    
    EnhancedPrivateChat(const std::string& u1, const std::string& u2) 
        : user1(u1), user2(u2), createTime(time(nullptr)), lastActiveTime(time(nullptr)) {
        // 生成聊天ID (按字典序排序确保唯一性)
        if (u1 < u2) {
            chatId = u1 + "_" + u2;
        } else {
            chatId = u2 + "_" + u1;
        }
    }
};

// 群组信息
struct GroupInfo {
    std::string groupId;         // 群组ID
    std::string groupName;       // 群组名称
    std::string description;     // 群组描述
    std::string ownerId;         // 群主ID
    std::unordered_set<std::string> admins;     // 管理员列表
    std::unordered_set<std::string> members;    // 成员列表
    int maxMembers;              // 最大成员数
    time_t createTime;           // 创建时间
    std::vector<EnhancedMessage> messages;      // 群消息历史
    
    GroupInfo(const std::string& id, const std::string& name, const std::string& owner)
        : groupId(id), groupName(name), ownerId(owner), maxMembers(500), createTime(time(nullptr)) {
        members.insert(owner);  // 群主自动成为成员
    }
    
    // 检查用户是否为群成员
    bool isMember(const std::string& userId) const {
        return members.find(userId) != members.end();
    }
    
    // 检查用户是否为管理员
    bool isAdmin(const std::string& userId) const {
        return admins.find(userId) != admins.end() || userId == ownerId;
    }
    
    // 添加成员
    bool addMember(const std::string& userId) {
        if (members.size() >= maxMembers) return false;
        members.insert(userId);
        return true;
    }
    
    // 移除成员
    void removeMember(const std::string& userId) {
        members.erase(userId);
        admins.erase(userId);
    }
};

// 用户信息
struct UserInfo {
    std::string userId;          // 用户ID
    std::string nickname;        // 昵称
    UserStatus status;           // 在线状态
    int socketFd;               // Socket连接
    std::string ip;             // IP地址
    time_t loginTime;           // 登录时间
    time_t lastActiveTime;      // 最后活跃时间
    
    // 私聊会话列表
    std::unordered_set<std::string> privateChats;
    
    // 群组列表
    std::unordered_set<std::string> groups;
    
    UserInfo(const std::string& id, int socket, const std::string& addr)
        : userId(id), nickname(id), status(STATUS_ONLINE), socketFd(socket), 
          ip(addr), loginTime(time(nullptr)), lastActiveTime(time(nullptr)) {}
};

// 聊天系统管理器
class EnhancedChatSystem {
private:
    // 用户管理
    std::unordered_map<std::string, std::shared_ptr<UserInfo>> users;
    std::unordered_map<int, std::string> socketToUser;  // socket -> userId 映射
    
    // 私聊管理
    std::unordered_map<std::string, std::shared_ptr<PrivateChat>> privateChats;
    
    // 群组管理
    std::unordered_map<std::string, std::shared_ptr<GroupInfo>> groups;
    
    // 线程安全
    std::mutex usersMutex;
    std::mutex chatsMutex;
    std::mutex groupsMutex;

public:
    // 用户管理
    bool addUser(const std::string& userId, int socketFd, const std::string& ip);
    void removeUser(const std::string& userId);
    std::shared_ptr<UserInfo> getUser(const std::string& userId);
    std::vector<std::shared_ptr<UserInfo>> getOnlineUsers();
    
    // 私聊管理
    std::string startPrivateChat(const std::string& user1, const std::string& user2);
    bool sendPrivateMessage(const std::string& fromUser, const std::string& toUser, const std::string& content);
    std::shared_ptr<PrivateChat> getPrivateChat(const std::string& user1, const std::string& user2);
    
    // 群组管理
    std::string createGroup(const std::string& groupName, const std::string& ownerId, const std::string& description = "");
    bool joinGroup(const std::string& groupId, const std::string& userId);
    bool leaveGroup(const std::string& groupId, const std::string& userId);
    bool sendGroupMessage(const std::string& groupId, const std::string& fromUser, const std::string& content);
    bool inviteToGroup(const std::string& groupId, const std::string& inviterId, const std::string& inviteeId);
    std::shared_ptr<GroupInfo> getGroup(const std::string& groupId);
    std::vector<std::shared_ptr<GroupInfo>> getUserGroups(const std::string& userId);
    
    // 消息路由
    void routeMessage(const EnhancedMessage& message);
    void sendToUser(const std::string& userId, const EnhancedMessage& message);
    void broadcastToGroup(const std::string& groupId, const EnhancedMessage& message, const std::string& excludeUser = "");
    
    // 工具方法
    std::string generateId();
    std::string generateChatId(const std::string& user1, const std::string& user2);
    bool isUserOnline(const std::string& userId);
    void updateUserActivity(const std::string& userId);
};

#endif // ENHANCED_CHAT_SYSTEM_H 